home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / dist-packages / DistUpgrade / distro.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-12  |  13.2 KB  |  454 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import gettext
  5. import re
  6. import os
  7. import sys
  8. from xml.etree.ElementTree import ElementTree
  9. import gettext
  10.  
  11. def _(s):
  12.     return gettext.dgettext('python-apt', s)
  13.  
  14.  
  15. class NoDistroTemplateException(Exception):
  16.     pass
  17.  
  18.  
  19. class Distribution:
  20.     
  21.     def __init__(self, id, codename, description, release):
  22.         ''' Container for distribution specific informations '''
  23.         self.id = id
  24.         self.codename = codename
  25.         self.description = description
  26.         self.release = release
  27.         self.binary_type = 'deb'
  28.         self.source_type = 'deb-src'
  29.  
  30.     
  31.     def get_sources(self, sourceslist):
  32.         '''
  33.         Find the corresponding template, main and child sources
  34.         for the distribution
  35.         '''
  36.         self.sourceslist = sourceslist
  37.         self.source_template = None
  38.         self.child_sources = []
  39.         self.main_sources = []
  40.         self.disabled_sources = []
  41.         self.cdrom_sources = []
  42.         self.download_comps = []
  43.         self.enabled_comps = []
  44.         self.cdrom_comps = []
  45.         self.used_media = []
  46.         self.get_source_code = False
  47.         self.source_code_sources = []
  48.         self.default_server = ''
  49.         self.main_server = ''
  50.         self.nearest_server = ''
  51.         self.used_servers = []
  52.         for template in self.sourceslist.matcher.templates:
  53.             if self.is_codename(template.name) and template.distribution == self.id:
  54.                 self.source_template = template
  55.                 break
  56.                 continue
  57.         
  58.         if self.source_template is None:
  59.             raise NoDistroTemplateException('Error: could not find a distribution template')
  60.         self.source_template is None
  61.         media = []
  62.         comps = []
  63.         cdrom_comps = []
  64.         enabled_comps = []
  65.         source_code = []
  66.         for source in self.sourceslist.list:
  67.             if source.invalid == False and self.is_codename(source.dist) and source.template and self.is_codename(source.template.name):
  68.                 if source.uri.startswith('cdrom:') and source.disabled == False:
  69.                     self.cdrom_sources.append(source)
  70.                     cdrom_comps.extend(source.comps)
  71.                 elif source.uri.startswith('cdrom:') and source.disabled == True:
  72.                     self.cdrom_sources.append(source)
  73.                 elif source.type == self.binary_type and source.disabled == False:
  74.                     self.main_sources.append(source)
  75.                     comps.extend(source.comps)
  76.                     media.append(source.uri)
  77.                 elif source.type == self.binary_type and source.disabled == True:
  78.                     self.disabled_sources.append(source)
  79.                 elif source.type == self.source_type and source.disabled == False:
  80.                     self.source_code_sources.append(source)
  81.                 elif source.type == self.source_type and source.disabled == True:
  82.                     self.disabled_sources.append(source)
  83.                 
  84.             
  85.             if source.invalid == False and source.template in self.source_template.children:
  86.                 if source.disabled == False and source.type == self.binary_type:
  87.                     self.child_sources.append(source)
  88.                 elif source.disabled == False and source.type == self.source_type:
  89.                     self.source_code_sources.append(source)
  90.                 else:
  91.                     self.disabled_sources.append(source)
  92.             source.type == self.source_type
  93.         
  94.         self.download_comps = set(comps)
  95.         self.cdrom_comps = set(cdrom_comps)
  96.         enabled_comps.extend(comps)
  97.         enabled_comps.extend(cdrom_comps)
  98.         self.enabled_comps = set(enabled_comps)
  99.         self.used_media = set(media)
  100.         self.get_mirrors()
  101.  
  102.     
  103.     def get_mirrors(self, mirror_template = None):
  104.         '''
  105.         Provide a set of mirrors where you can get the distribution from
  106.         '''
  107.         self.main_server = self.source_template.base_uri
  108.         for medium in self.used_media:
  109.             if not medium.startswith('cdrom:'):
  110.                 self.used_servers.append(medium)
  111.                 continue
  112.         
  113.         if len(self.main_sources) == 0:
  114.             self.default_server = self.main_server
  115.         else:
  116.             self.default_server = self.main_sources[0].uri
  117.         self.countries = { }
  118.         fname = '/usr/share/xml/iso-codes/iso_3166.xml'
  119.         if os.path.exists(fname):
  120.             et = ElementTree(file = fname)
  121.             it = et.getiterator('iso_3166_entry')
  122.             for elm in it:
  123.                 if elm.attrib.has_key('common_name'):
  124.                     descr = elm.attrib['common_name']
  125.                 else:
  126.                     descr = elm.attrib['name']
  127.                 if elm.attrib.has_key('alpha_2_code'):
  128.                     code = elm.attrib['alpha_2_code']
  129.                 else:
  130.                     code = elm.attrib['alpha_3_code']
  131.                 self.countries[code.lower()] = gettext.dgettext('iso_3166', descr)
  132.             
  133.         
  134.         self.country = None
  135.         self.country_code = None
  136.         locale = os.getenv('LANG', default = 'en_UK')
  137.         a = locale.find('_')
  138.         z = locale.find('.')
  139.         if z == -1:
  140.             z = len(locale)
  141.         
  142.         country_code = locale[a + 1:z].lower()
  143.         if mirror_template:
  144.             self.nearest_server = mirror_template % country_code
  145.         
  146.         if country_code in self.countries:
  147.             self.country = self.countries[country_code]
  148.             self.country_code = country_code
  149.         
  150.  
  151.     
  152.     def _get_mirror_name(self, server):
  153.         ''' Try to get a human readable name for the main mirror of a country
  154.             Customize for different distributions '''
  155.         country = None
  156.         i = server.find('://')
  157.         l = server.find('.archive.ubuntu.com')
  158.         if i != -1 and l != -1:
  159.             country = server[i + len('://'):l]
  160.         
  161.         if country in self.countries:
  162.             return _('Server for %s') % self.countries[country]
  163.         return '%s' % server.rstrip('/ ')
  164.  
  165.     
  166.     def get_server_list(self):
  167.         ''' Return a list of used and suggested servers '''
  168.         
  169.         def compare_mirrors(mir1, mir2):
  170.             ''' Helper function that handles comaprision of mirror urls
  171.                 that could contain trailing slashes'''
  172.             return re.match(mir1.strip('/ '), mir2.rstrip('/ '))
  173.  
  174.         mirrors = []
  175.         if (len(self.used_servers) < 1 or len(self.used_servers) == 1) and compare_mirrors(self.used_servers[0], self.main_server):
  176.             mirrors.append([
  177.                 _('Main server'),
  178.                 self.main_server,
  179.                 True])
  180.             if self.nearest_server:
  181.                 mirrors.append([
  182.                     self._get_mirror_name(self.nearest_server),
  183.                     self.nearest_server,
  184.                     False])
  185.             
  186.         elif len(self.used_servers) == 1 and not compare_mirrors(self.used_servers[0], self.main_server):
  187.             mirrors.append([
  188.                 _('Main server'),
  189.                 self.main_server,
  190.                 False])
  191.             server = self.used_servers[0]
  192.             if self.nearest_server:
  193.                 if not compare_mirrors(server, self.nearest_server):
  194.                     mirrors.append([
  195.                         self._get_mirror_name(self.nearest_server),
  196.                         self.nearest_server,
  197.                         False])
  198.                 
  199.             
  200.             if server:
  201.                 mirrors.append([
  202.                     self._get_mirror_name(server),
  203.                     server,
  204.                     True])
  205.             
  206.         elif len(self.used_servers) > 1:
  207.             mirrors.append([
  208.                 _('Main server'),
  209.                 self.main_server,
  210.                 False])
  211.             if self.nearest_server:
  212.                 mirrors.append([
  213.                     self._get_mirror_name(self.nearest_server),
  214.                     self.nearest_server,
  215.                     False])
  216.             
  217.             mirrors.append([
  218.                 _('Custom servers'),
  219.                 None,
  220.                 True])
  221.             for server in self.used_servers:
  222.                 mirror_entry = [
  223.                     self._get_mirror_name(server),
  224.                     server,
  225.                     False]
  226.                 if compare_mirrors(server, self.nearest_server) or compare_mirrors(server, self.main_server):
  227.                     continue
  228.                     continue
  229.                 if mirror_entry not in mirrors:
  230.                     mirrors.append(mirror_entry)
  231.                     continue
  232.             
  233.         
  234.         return mirrors
  235.  
  236.     
  237.     def add_source(self, type = None, uri = None, dist = None, comps = None, comment = ''):
  238.         '''
  239.         Add distribution specific sources
  240.         '''
  241.         if uri is None:
  242.             uri = self.default_server
  243.         
  244.         if dist is None:
  245.             dist = self.codename
  246.         
  247.         if comps is None:
  248.             comps = list(self.enabled_comps)
  249.         
  250.         if type is None:
  251.             type = self.binary_type
  252.         
  253.         new_source = self.sourceslist.add(type, uri, dist, comps, comment)
  254.         if self.get_source_code == True and type == self.binary_type:
  255.             self.sourceslist.add(self.source_type, uri, dist, comps, comment, file = new_source.file, pos = self.sourceslist.list.index(new_source) + 1)
  256.         
  257.  
  258.     
  259.     def enable_component(self, comp):
  260.         '''
  261.         Enable a component in all main, child and source code sources
  262.         (excluding cdrom based sources)
  263.  
  264.         comp:         the component that should be enabled
  265.         '''
  266.         
  267.         def add_component_only_once(source, comps_per_dist):
  268.             '''
  269.             Check if we already added the component to the repository, since
  270.             a repository could be splitted into different apt lines. If not
  271.             add the component
  272.             '''
  273.             if source.dist not in comps_per_dist:
  274.                 return None
  275.             if comp in comps_per_dist[source.dist]:
  276.                 return None
  277.             source.comps.append(comp)
  278.             comps_per_dist[source.dist].add(comp)
  279.  
  280.         sources = []
  281.         sources.extend(self.main_sources)
  282.         sources.extend(self.child_sources)
  283.         comps_per_dist = { }
  284.         comps_per_sdist = { }
  285.         for s in sources:
  286.             if s.type == self.binary_type:
  287.                 if s.dist not in comps_per_dist:
  288.                     comps_per_dist[s.dist] = set()
  289.                     map(comps_per_dist[s.dist].add, s.comps)
  290.                 
  291.             s.dist not in comps_per_dist
  292.         
  293.         for s in self.source_code_sources:
  294.             if s.type == self.source_type:
  295.                 if s.dist not in comps_per_sdist:
  296.                     comps_per_sdist[s.dist] = set()
  297.                     map(comps_per_sdist[s.dist].add, s.comps)
  298.                 
  299.             s.dist not in comps_per_sdist
  300.         
  301.         if len(self.main_sources) < 1:
  302.             self.add_source(comps = [
  303.                 '%s' % comp])
  304.         else:
  305.             for source in sources:
  306.                 add_component_only_once(source, comps_per_dist)
  307.             
  308.         if self.get_source_code == True:
  309.             if len(self.source_code_sources) < 1:
  310.                 self.add_source(type = self.source_type, comps = [
  311.                     '%s' % comp])
  312.             else:
  313.                 for source in self.source_code_sources:
  314.                     add_component_only_once(source, comps_per_sdist)
  315.                 
  316.         
  317.  
  318.     
  319.     def disable_component(self, comp):
  320.         '''
  321.         Disable a component in all main, child and source code sources
  322.         (excluding cdrom based sources)
  323.         '''
  324.         sources = []
  325.         sources.extend(self.main_sources)
  326.         sources.extend(self.child_sources)
  327.         sources.extend(self.source_code_sources)
  328.         if comp in self.cdrom_comps:
  329.             sources = []
  330.             sources.extend(self.main_sources)
  331.         
  332.         for source in sources:
  333.             if comp in source.comps:
  334.                 source.comps.remove(comp)
  335.                 if len(source.comps) < 1:
  336.                     self.sourceslist.remove(source)
  337.                 
  338.             len(source.comps) < 1
  339.         
  340.  
  341.     
  342.     def change_server(self, uri):
  343.         ''' Change the server of all distro specific sources to
  344.             a given host '''
  345.         
  346.         def change_server_of_source(source, uri, seen):
  347.             source.uri = uri
  348.             for comp in source.comps:
  349.                 if [
  350.                     source.uri,
  351.                     source.dist,
  352.                     comp] in seen:
  353.                     source.comps.remove(comp)
  354.                     continue
  355.                 seen.append([
  356.                     source.uri,
  357.                     source.dist,
  358.                     comp])
  359.             
  360.             if len(source.comps) < 1:
  361.                 self.sourceslist.remove(source)
  362.             
  363.  
  364.         seen_binary = []
  365.         seen_source = []
  366.         self.default_server = uri
  367.         for source in self.main_sources:
  368.             change_server_of_source(source, uri, seen_binary)
  369.         
  370.         for source in self.child_sources:
  371.             if source.template.base_uri is None or source.template.base_uri != source.uri:
  372.                 change_server_of_source(source, uri, seen_binary)
  373.                 continue
  374.             (None,)
  375.         
  376.         for source in self.source_code_sources:
  377.             change_server_of_source(source, uri, seen_source)
  378.         
  379.  
  380.     
  381.     def is_codename(self, name):
  382.         ''' Compare a given name with the release codename. '''
  383.         if name == self.codename:
  384.             return True
  385.         return False
  386.  
  387.  
  388.  
  389. class DebianDistribution(Distribution):
  390.     ''' Class to support specific Debian features '''
  391.     
  392.     def is_codename(self, name):
  393.         ''' Compare a given name with the release codename and check if
  394.             if it can be used as a synonym for a development releases '''
  395.         if name == self.codename or self.release in ('testing', 'unstable'):
  396.             return True
  397.         return False
  398.  
  399.     
  400.     def _get_mirror_name(self, server):
  401.         ''' Try to get a human readable name for the main mirror of a country
  402.             Debian specific '''
  403.         country = None
  404.         i = server.find('://ftp.')
  405.         l = server.find('.debian.org')
  406.         if i != -1 and l != -1:
  407.             country = server[i + len('://ftp.'):l]
  408.         
  409.         if country in self.countries:
  410.             return _('Server for %s') % gettext.dgettext('iso_3166', self.countries[country].rstrip()).rstrip()
  411.         return '%s' % server.rstrip('/ ')
  412.  
  413.     
  414.     def get_mirrors(self):
  415.         Distribution.get_mirrors(self, mirror_template = 'http://ftp.%s.debian.org/debian/')
  416.  
  417.  
  418.  
  419. class UbuntuDistribution(Distribution):
  420.     ''' Class to support specific Ubuntu features '''
  421.     
  422.     def get_mirrors(self):
  423.         Distribution.get_mirrors(self, mirror_template = 'http://%s.archive.ubuntu.com/ubuntu/')
  424.  
  425.  
  426.  
  427. def get_distro(id = None, codename = None, description = None, release = None):
  428.     '''
  429.     Check the currently used distribution and return the corresponding
  430.     distriubtion class that supports distro specific features.
  431.  
  432.     If no paramter are given the distro will be auto detected via
  433.     a call to lsb-release
  434.     '''
  435.     if not id and codename and description and release:
  436.         lsb_info = []
  437.         for lsb_option in [
  438.             '-i',
  439.             '-c',
  440.             '-d',
  441.             '-r']:
  442.             pipe = os.popen('lsb_release %s -s' % lsb_option)
  443.             lsb_info.append(pipe.read().strip())
  444.             del pipe
  445.         
  446.         (id, codename, description, release) = lsb_info
  447.     
  448.     if id == 'Ubuntu':
  449.         return UbuntuDistribution(id, codename, description, release)
  450.     if id == 'Debian':
  451.         return DebianDistribution(id, codename, description, release)
  452.     return Distribution(id, codename, description, release)
  453.  
  454.